/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controladores;

import io.*;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import persistencia.*;
import ui.Fecha;
//import persistencia.DAOException;
import persistencia.MySQLDAOFactory;
import java.io.*;

/**
 * Esta clase representa al controlador de la aplicación
 * @author Nahuel
 */
public class Fachada {

    /**
     * Este método devuelve una lista con todas las entradas de agenda
     * almacenadas en la base de datos
     * @return agenda
     * @throws DAOException excepción de la capa DAO del sistema
     */
    public ArrayList<AgendaDTO> listarAgenda() throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getAgendaDAO().listarAgenda();
    }

    /**
     * Este método devuelve una lista con todos los movimientos de gestoria
     * almacenados en la base de datos
     * @return lista de gestoria
     * @throws DAOException excepción de la capa DAO del sistema
     */
    public ArrayList<CajaChicaDTO> listarGestoria(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().listarGestoria(fecha);
    }

    /**
     * Este método devuelve una lista con todos los movimientos de gestoria
     * almacenados en la base de datos
     * @return lista de gestoria
     * @throws DAOException excepción de la capa DAO del sistema
     */
    public ArrayList<CajaChicaDTO> listarVarios(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().listarVarios(fecha);
    }

    public ArrayList<RepuestosServicesMotoEntregaDTO> listarRespuestosServicesMotoEntrega(Date fecha, String tipo) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().listarRepuestosServicesMotoEntrega(fecha, tipo);
    }

    public ArrayList<MotoCuotaDTO> listarMotoCuota(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getMotoCuotaDAO().listarMotoCuota(fecha);
    }

    /**
     * Este método devuelve una lista con todos los movimientos de gastos
     * almacenados en la base de datos
     * @param fecha
     * @return lista de gastos
     * @throws DAOException 
     */
    public ArrayList<CajaChicaDTO> listarGastos(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().listarGastos(fecha);
    }

    /**
     * Este mensaje permite insertar una nueva entrada en la agenda
     * de la base de datos
     * @param nombre
     * @param apellido
     * @param direccion
     * @param telefono
     * @param email
     * @param observaciones
     * @throws DAOException 
     */
    public void crearAgenda(AgendaDTO agenda) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getAgendaDAO().insertarAgenda(agenda);
    }

    /**
     * Este método permite eliminar una entrada de la agenda de la base de datos
     * @param id
     * @return true si se elimino correctamente, false en caso contrario
     * @throws DAOException 
     */
    public boolean eliminarAgenda(int id) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getAgendaDAO().borrarAgenda(id);
    }

    /**
     * Este método permite modificar un contacto de la agenda de la base de 
     * datos
     * @param agenda
     * @throws DAOException 
     */
    public void actualizarAgenda(AgendaDTO agenda) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getAgendaDAO().actualizarAgenda(agenda);
    }

    /**
     * Este método devuelve una lista con todas los contactos almacenadas en
     * la agenda de la base de datos que contengan los datos que contine en los
     * atributos el objeto agenda
     * @param agenda
     * @return lista de agenda
     * @throws DAOException 
     */
    public ArrayList<AgendaDTO> buscarAgenda(AgendaDTO agenda) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getAgendaDAO().buscarAgenda(agenda);
    }

    /**
     * Este método devuelve una persona con el dni que se le pasa como parámetro
     * o una persona con todos los campos vacios si no existe una coincidencia
     * @param dni
     * @return
     * @throws DAOException 
     */
    public PersonaDTO buscarPersona(int dni) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getPersonaDAO().buscarPersona(dni);
    }

    /**
     * Este método permite agregar una venta a la base de datos
     * @param venta 
     */
    public void agregarVenta(VentaDTO venta) throws DAOException {
        this.prepararPersona(venta.getCliente());
        if (venta.getGarante1() != null) {
            this.prepararPersona(venta.getGarante1());
        }
        if (venta.getGarante2() != null) {
            this.prepararPersona(venta.getGarante2());
        }
        //Guardo la venta 
        MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().agregarVenta(venta);
        //Si la venta fue de una moto guardamos la moto en la bd
        if (venta.getMoto() != null) {
            venta.getMoto().setIdVenta(venta.getId());
            MySQLDAOFactory.getMySQLDAOFactory().getMotoDAO().agregarMoto(venta.getMoto());
        }
        if (venta.getPlan() != null) {
            venta.getPlan().setNumero(1);
            MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().agregarPlan(venta.getPlan(), venta.getId());
            this.agregarCuotasPlan(venta.getPlan(), 1);
        }

    }

    /**
     * Este método crea o actualiza una persona dependiendo si tiene o no 
     * seteado el id.
     * @param persona
     * @throws DAOException 
     */
    public void prepararPersona(PersonaDTO persona) throws DAOException {
        if (persona.getId() == 0) {
            MySQLDAOFactory.getMySQLDAOFactory().getPersonaDAO().agregarPersona(persona);
        } else {
            MySQLDAOFactory.getMySQLDAOFactory().getPersonaDAO().actualizarPersona(persona);
        }
    }

    /**
     * Este método devuelve una lista con todas las ventas
     * almacenadas en la base de datos
     * @return 
     */
    public ArrayList<VentaDTO> listarVenta() throws DAOException {
        ArrayList<VentaDTO> ventas = MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().listarVentas();
        Iterator<VentaDTO> it = ventas.iterator();
        while (it.hasNext()) {
            VentaDTO venta = it.next();
            this.completarPersona(venta.getCliente());
            if (venta.getTipo().equalsIgnoreCase("Motovehículo")) {
                MotoDTO moto = MySQLDAOFactory.getMySQLDAOFactory().getMotoDAO().getMotoByVentaId(venta.getId());
                venta.setMoto(moto);
            }
        }
        return ventas;
    }

    /**
     * Este método devuelve una persona con todos los datos si la misma posee id
     * @param persona
     * @throws DAOException 
     */
    public void completarPersona(PersonaDTO persona) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getPersonaDAO().completarPersona(persona);
    }

    /**
     * Este método devuelve una lista de ventas que coincida con los parametros
     * de busqueda que se le pasan
     * @param fecha
     * @param cliente
     * @param descripcion
     * @param tipo
     * @return
     * @throws DAOException 
     */
    public ArrayList<VentaDTO> buscarVenta(String fecha, String cliente, String descripcion, String tipo) throws DAOException {
        ArrayList<VentaDTO> ventas = this.listarVenta();
        ArrayList<VentaDTO> ventas2 = new ArrayList<VentaDTO>();
        Iterator<VentaDTO> it = ventas.iterator();
        while (it.hasNext()) {
            VentaDTO venta = it.next();
            if ((Fecha.formatearFecha(venta.getFecha()).toLowerCase().contains(fecha)) && (venta.getCliente().getNombre().toLowerCase().contains(cliente)) && (venta.getTipo().toLowerCase().contains(tipo))) {
                if (venta.getTipo().equalsIgnoreCase("Motovehículo")) {
                    String descrip = venta.getMoto().getMarca() + " - " + venta.getMoto().getModelo();
                    if (descrip.toLowerCase().contains(descripcion)) {
                        ventas2.add(venta);
                    }
                } else {
                    if (venta.getDescripcion().toLowerCase().contains(descripcion)) {
                        ventas2.add(venta);
                    }
                }
            }
        }
        return ventas2;
    }

    /**
     * Este método devuelve una lista de ventas que coincida con los parametros
     * de busqueda que se le pasan
     * @param fecha
     * @param cliente
     * @param descripcion
     * @param tipo
     * @return
     * @throws DAOException 
     */
    public ArrayList<VentaReducidaDTO> buscarVenta2(String fecha, String cliente) throws DAOException {
        ArrayList<VentaReducidaDTO> ventas = MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().buscarVentas(cliente);
        Iterator<VentaReducidaDTO> it = ventas.iterator();
        while (it.hasNext()) {
            VentaReducidaDTO venta = it.next();
            if (!Fecha.formatearFecha(venta.getFecha()).toLowerCase().contains(fecha)) {
                it.remove();
            }
        }
        return ventas;
    }

    /**
     * Este método devuelve una venta pasandole como parámetro el id de la misma
     * @param id
     * @return
     * @throws DAOException 
     */
    public VentaDTO getVenta(int id) throws DAOException {
        VentaDTO venta = MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().getVenta(id);
        this.completarPersona(venta.getCliente());

        if (venta.getTipo().equalsIgnoreCase("Motovehículo")) {
            MotoDTO moto = MySQLDAOFactory.getMySQLDAOFactory().getMotoDAO().getMotoByVentaId(venta.getId());
            venta.setMoto(moto);
        }
        ArrayList<PlanDTO> planes = MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().getPlan(id);
        if (planes != null) {
            Iterator<PlanDTO> it = planes.iterator();
            while (it.hasNext()) {
                PlanDTO plan = it.next();
                plan.setCuotas(this.obtenerCoutas(plan.getId()));
            }
            venta.setPlanes(planes);
            if (venta.getGarante1() != null) {
                this.completarPersona(venta.getGarante1());
            }
            if (venta.getGarante2() != null) {
                this.completarPersona(venta.getGarante2());
            }
        }
        return venta;
    }

    /**
     * Este método devuelve un array con todas las cuotas de un plan
     * @param idPlan
     * @return
     * @throws DAOException 
     */
    private ArrayList<CuotaDTO> obtenerCoutas(int idPlan) throws DAOException {
        ArrayList<CuotaDTO> cuotas = MySQLDAOFactory.getMySQLDAOFactory().getCuotaDAO().getCuotas(idPlan);
        Iterator<CuotaDTO> it = cuotas.iterator();
        while (it.hasNext()) {
            CuotaDTO cuota = it.next();
            cuota.setPagos(MySQLDAOFactory.getMySQLDAOFactory().getPagoDAO().getPagos(cuota.getId()));
        }
        return cuotas;
    }

    /**
     * Este método permite agregarle un mes a una fecha determinada
     * @param fecha
     * @return 
     */
    private Date agregarMes(Date fecha) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(fecha);
        cal.add(Calendar.MONTH, 1);
        java.sql.Date fechaSQL = new java.sql.Date(cal.getTime().getTime());
        return fechaSQL;
    }

    /**
     * Este método permite actualizar los datos de un pago en la base de datos
     * @param pago
     * @throws DAOException 
     */
    public void actualizarPago(PagoDTO pago) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getPagoDAO().actualizarPago(pago);
    }

    /**
     * Este métdodo permite agregar un pago a la base de datos
     * @param id
     * @param fechaPago
     * @param montoPagado
     * @param descripcion
     * @throws DAOException 
     */
    public void agregarPago(PagoDTO pago) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getPagoDAO().agregarPago(pago);
    }

    /**
     * Este método permite obtener todos los pagos de una determinada cuota
     * @param id identificador de la cuota
     * @return
     * @throws DAOException 
     */
    public ArrayList<PagoDTO> obtenerPagos(int id) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getPagoDAO().getPagos(id);
    }

    /**
     * Este método permite testear la conexión con la base de datos
     * @throws DAOException 
     */
    public void testearConexion() throws DAOException {
        this.setearConfiguraciónBaseDeDatos();
        MySQLDAOFactory.getMySQLDAOFactory().testConexion();
    }

    /**
     * Este método permite actualizar los datos de una venta comparándo los
     * mismos con los almacenados en la base de datos
     * @param venta VentaDTO modificada
     * @throws DAOException 
     */
    public void actualizarVenta(VentaDTO venta) throws DAOException {
        VentaDTO ventaSinCambios = this.getVenta(venta.getId());
        boolean actualizarVenta = false;
        if (!venta.getCliente().equalsTo(ventaSinCambios.getCliente())) {
            this.prepararPersona(venta.getCliente());
            actualizarVenta = true;
        }
        if (venta.getGarante1() != null && !venta.getGarante1().equalsTo(ventaSinCambios.getGarante1())) {
            this.prepararPersona(venta.getGarante1());
            actualizarVenta = true;
        }
        if (venta.getGarante2() != null && !venta.getGarante2().equalsTo(ventaSinCambios.getGarante2())) {
            this.prepararPersona(venta.getGarante2());
            actualizarVenta = true;
        }
        //Guardo la venta 
        if (actualizarVenta || !venta.equalsTo(ventaSinCambios)) {
            MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().actualizarVenta(venta);
        }
        //Si la venta fue de una moto y se modifico guardamos la moto en la bd
        if (venta.getMoto() != null && !venta.getMoto().equals(ventaSinCambios.getMoto())) {
            venta.getMoto().setIdVenta(venta.getId());
            MySQLDAOFactory.getMySQLDAOFactory().getMotoDAO().actualizarMoto(venta.getMoto());
        }
    }

    /**
     * Este método permite cambiar el plan de una venta
     * @param venta
     * @param planVenta
     * @throws DAOException 
     */
    public void cambiarPlan(VentaDTO venta, PlanDTO planVenta, int iniciarCuotasEn) throws DAOException {
        PlanDTO planViejo = venta.getPlanActivo();
        //eliminar cuotas impagas de plan anterior
        Iterator<CuotaDTO> it = planViejo.getCuotas().iterator();
        while (it.hasNext()) {
            CuotaDTO cuota = it.next();
            if (cuota.getEstado().equalsIgnoreCase("Impaga")) {
                MySQLDAOFactory.getMySQLDAOFactory().getCuotaDAO().eliminarCuota(cuota.getId());
            }
        }
        //setear como inactivo el plan actualmente activo
        MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().desactivarPlan(planViejo.getId());
        //agregar nuevo plan y crear cuotas
        planVenta.setNumero(planViejo.getNumero() + 1);
        MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().agregarPlan(planVenta, venta.getId());
        this.agregarCuotasPlan(planVenta, iniciarCuotasEn);
    }

    /**
     * Este método permite crear todas las cuotas para un plan y agregarlas a la
     * base de datos
     * @param plan
     * @throws DAOException 
     */
    private void agregarCuotasPlan(PlanDTO plan, int iniciarCuotasEn) throws DAOException {
        CuotaDTO cuota = new CuotaDTO();
        java.sql.Date fecha = null;
        for (int i = 1; i <= plan.getNumCoutas(); i++) {
            cuota.setNumero(iniciarCuotasEn + i - 1);
            cuota.setMonto(plan.getMontoCoutas());
            if (i == 1) {
                fecha = plan.getFechaIncicio();
            } else {
                fecha = this.agregarMes(fecha);
            }
            cuota.setFechaVencimiento(fecha);
            MySQLDAOFactory.getMySQLDAOFactory().getCuotaDAO().agregarCuota(cuota, plan.getId());
        }
    }

    /**
     * Este método permite insertar una nueva gestoria a la base de datos
     */
    public void crearGestoria(CajaChicaDTO gestoria) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().insertarGestoria(gestoria);
    }

    /**
     * Este método permite insertar una nueva gestoria a la base de datos
     */
    public void crearVarios(CajaChicaDTO varios) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().insertarVarios(varios);
    }

    /**
     * Este método permite insertar un nuevo gasto a la base de datos
     * @param gastos
     * @throws DAOException 
     */
    public void crearGastos(CajaChicaDTO gastos) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().insertarGastos(gastos);
    }

    public boolean eliminarGestoria(int id) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().borrarGestoria(id);
    }

    public boolean eliminarVarios(int id) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().borrarVarios(id);
    }

    public boolean eliminarGastos(int id) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().borrarGastos(id);
    }

    /**
     * Este metodo permite calcular el total de Gestoria
     * @param fecha
     * @return
     * @throws DAOException 
     */
    public double totalGestoria(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().totalGestoria(fecha);

    }

    /**
     * Este metodo permite calcular el total de Gestoria
     * @param fecha
     * @return
     * @throws DAOException 
     */
    public double totalVarios(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().totalVarios(fecha);

    }

    public double totalCuotaMotoServicesRepuesto(Date fecha, String tipo) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getMotoCuotaDAO().totalCuotasMotoServicesRepuestos(fecha, tipo);
    }

    /**
     * este método permite calcular el total de Gastos
     * @param fecha
     * @return
     * @throws DAOException 
     */
    public double totalGastos(Date fecha) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().totalGastos(fecha);

    }

    /**
     * este metodo calcula el total en $ de las entregas ya sea de repeustos,
     * Services o moto
     * @param fecha
     * @param tipo
     * @return
     * @throws DAOException 
     */
    public double totalRepuestosServicesMotoEntrega(Date fecha, String tipo) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().totalRepuestosServicesMotoEntrega(fecha, tipo);
    }

    /**
     * Este método permite modificar un un movimiento de gestoria de la base de 
     * datos
     * @param gestoria
     * @throws DAOException 
     */
    public void actualizarGestoria(CajaChicaDTO gestoria) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().actualizarGestoria(gestoria);
    }

    /**
     * Este metodo permite modificar un un movimiento de varios de la base de 
     * datos
     * @param gestoria
     * @throws DAOException 
     */
    public void actualizarVarios(CajaChicaDTO varios) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().actualizarVarios(varios);
    }

    /**
     * Este metodo permite modificar un movimiento de gastos de la base de datos
     * @param gastos
     * @throws DAOException 
     */
    public void actualizarGastos(CajaChicaDTO gastos) throws DAOException {
        MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().actualizarGastos(gastos);
    }

    public ArrayList<CajaChicaDTO> buscarGestoria(CajaChicaDTO gestoria) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().buscarGestoria(gestoria);
    }

    public ArrayList<CajaChicaDTO> buscarVarios(CajaChicaDTO varios) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().buscarVarios(varios);
    }

    public ArrayList<CajaChicaDTO> buscarGastos(CajaChicaDTO gastos) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getCajaChicaDAO().buscarGastos(gastos);
    }

    public ArrayList<RepuestosServicesMotoEntregaDTO> buscarRepuestos(RepuestosServicesMotoEntregaDTO repuestos) throws DAOException {
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesCuotas = new ArrayList();
        listaRepuestosServicesCuotas = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoCuota(repuestos, "Repuestos");
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesMotoEntrega = new ArrayList();
        listaRepuestosServicesMotoEntrega = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoEntrega(repuestos, "Repuestos");
        listaRepuestosServicesCuotas.addAll(listaRepuestosServicesMotoEntrega);
        // return MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoEntrega(repuestos, "Repuestos");
        return listaRepuestosServicesCuotas;
    }

    public ArrayList<RepuestosServicesMotoEntregaDTO> buscarServices(RepuestosServicesMotoEntregaDTO services) throws DAOException {
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesCuotas = new ArrayList();
        listaRepuestosServicesCuotas = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoCuota(services, "Services");
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesMotoEntrega = new ArrayList();
        listaRepuestosServicesMotoEntrega = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoEntrega(services, "Services");
        listaRepuestosServicesCuotas.addAll(listaRepuestosServicesMotoEntrega);
        return listaRepuestosServicesCuotas;
        // return MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoEntrega(services, "Services");
    }

    public ArrayList<RepuestosServicesMotoEntregaDTO> buscarMotoEntrega(RepuestosServicesMotoEntregaDTO motoEntrega) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().buscarRepuestosServicesMotoEntrega(motoEntrega, "Motovehículo");
    }

    public ArrayList<MotoCuotaDTO> buscarMotoCuota(MotoCuotaDTO motoCuota) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getMotoCuotaDAO().buscarMotoCuota(motoCuota);
    }

    public ArrayList<MorososDTO> listarMorosos() throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getMorososDAO().listarMorosos();
    }

    /**
     * Este metodo devuelve una lista con los services o Repuestos ya sea los
     * que se vendieron en cuotas o de contado
     * @param fecha
     * @param tipo
     * @return
     * @throws DAOException 
     */
    public ArrayList<RepuestosServicesMotoEntregaDTO> listarServicesRepuestos(Date fecha, String tipo) throws DAOException {
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesCuotas = new ArrayList();
        listaRepuestosServicesCuotas = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().listarRepuestosServicesCuotas(fecha, tipo);
        ArrayList<RepuestosServicesMotoEntregaDTO> listaRepuestosServicesMotoEntrega = new ArrayList();
        listaRepuestosServicesMotoEntrega = MySQLDAOFactory.getMySQLDAOFactory().getRepuestosServicesMotoEntregaDAO().listarRepuestosServicesMotoEntrega(fecha, tipo);
        listaRepuestosServicesCuotas.addAll(listaRepuestosServicesMotoEntrega);
        return listaRepuestosServicesCuotas;
    }

    /**
     * Este método permite setear la url, el username y password a utilizar
     * en la conexión de la base de datos. Lo hace utilizando un archivo llamado
     * config.txt que debe estar en la carpeta del proyecto
     */
    private void setearConfiguraciónBaseDeDatos() throws DAOException {
        FileReader fr = null;
        try {
            fr = new FileReader("config.txt");
            BufferedReader bf = new BufferedReader(fr);
            String dburl = bf.readLine();
            MySQLDAOFactory.setDBURL(dburl);
            String dbuser = bf.readLine();
            MySQLDAOFactory.setDBUSR(dbuser);
            String dbpass = bf.readLine();
            MySQLDAOFactory.setDBPASS(dbpass);

        } catch (FileNotFoundException ex) {
            throw new DAOException("Error al buscar el archivo de configuración", ex);
        } catch (IOException ex) {
            throw new DAOException("Error leyendo el archivo de configuración", ex);
        } finally {
            try {
                fr.close();
            } catch (Exception ex) {
                throw new DAOException("Error cerrando el archivo de configuración", ex);
            }
        }
    }

    public ArrayList<InformeDiarioDTO> listarInformes(String fecha1, String fecha2) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getInformeDIario().getPagosMes(fecha1, fecha2);
    }

    public ArrayList<InformeDiarioDTO> listarInformeResumido(String fecha1, String fecha2, String mesPalabra) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getInformeDIario().getPagosMesResumen(fecha1, fecha2, mesPalabra);
    }

    public ArrayList<InfoClieMesDTO> listarInfoClieMes(String año) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getInfoClieMes().getInformesClieMes(año);
    }

    public ArrayList<InfoClieMesDTO> listarInfoClieMesResumen(String año) throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getInfoClieMes().getInformesClieMesResumen(año);
    }

    /**
     * Este método permite eliminar una venta y sus componentes relacionados de
     * la base de datos, excepto la persona que la realizo
     * @param venta
     * @throws DAOException 
     */
    public void eliminarVenta(VentaDTO venta) throws DAOException {
        //Elimino la venta 
        MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().eliminarVenta(venta.getId());
        //Si la venta fue de una moto eliminamos la moto de la bd
        if (venta.getMoto() != null) {
            MySQLDAOFactory.getMySQLDAOFactory().getMotoDAO().eliminarMoto(venta.getMoto().getId());
        }
        if (venta.getPlanes() != null) {
            Iterator<PlanDTO> itPlan = venta.getPlanes().iterator();
            while (itPlan.hasNext()) {
                PlanDTO plan = itPlan.next();
                //eliminar cuotas del plan
                Iterator<CuotaDTO> itCuota = plan.getCuotas().iterator();
                while (itCuota.hasNext()) {
                    CuotaDTO cuota = itCuota.next();
                    MySQLDAOFactory.getMySQLDAOFactory().getCuotaDAO().eliminarCuota(cuota.getId());
                }
                //eliminar el plan
                MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().eliminarPlan(plan.getId());
            }


        }
    }

    /**
     * Este método permite eliminar una plan y sus cuotas relacionados de
     * la base de datos
     * @param plan
     * @throws DAOException 
     */
    public void eliminarPlan(PlanDTO plan) throws DAOException {
        //eliminar cuotas del plan
        Iterator<CuotaDTO> itCuota = plan.getCuotas().iterator();
        while (itCuota.hasNext()) {
            CuotaDTO cuota = itCuota.next();
            MySQLDAOFactory.getMySQLDAOFactory().getCuotaDAO().eliminarCuota(cuota.getId());
        }
        //eliminar el plan
        MySQLDAOFactory.getMySQLDAOFactory().getPlanDAO().eliminarPlan(plan.getId());
    }
    
    /**
     * Este método devuelve una lista con todas las ventas
     * almacenadas en la base de datos
     * @return 
     */
    public ArrayList<VentaReducidaDTO> listarVenta2() throws DAOException {
        return MySQLDAOFactory.getMySQLDAOFactory().getVentaDAO().listarVentas2();
    }
}